import axios from 'axios'
import { ElMessage } from 'element-plus'
import router from '@/router'

const service = axios.create({
  baseURL: 'https://vue.haozskj.com', // 大多数接口使用这个域名
  timeout: 15000,
  headers: {
    'Content-Type': 'text/plain; charset=utf-8'
  }
})

// 创建用于序列号校验的单独实例
export const serialVerifyService = axios.create({
  baseURL: 'https://vuezfqtest.haozskj.com',
  timeout: 15000,
  headers: {
    'Content-Type': 'text/plain; charset=utf-8'
  }
})

// 序列号校验服务的响应拦截器
serialVerifyService.interceptors.response.use(
  response => {
    // console.log('序列号校验原始响应:', response);
    
    // 直接检查是否有data字段，并且是否有预期的格式
    if (response.data && typeof response.data === 'object' && response.data.leixing === 'ok') {
    //   console.log('序列号校验直接返回OK响应:', response.data);
      return response.data;
    }
   
    let res;
    // 先尝试按照字符串处理
    if (typeof response.data === 'string') {
      try {
        res = JSON.parse(response.data);
        // console.log('序列号校验解析后的字符串响应:', res);
        
        // 如果是 {"leixing":"ok"} 格式，直接返回
        if (res && res.leixing === 'ok') {
          return res;
        }
      } catch (e) {
        // console.log('序列号校验响应不是JSON格式，按原样返回:', response.data);
        return response.data;
      }
    } else {
      res = response.data;
    }
    
    // 处理对象类型响应
    if (res && typeof res === 'object') {
    //   console.log('序列号校验处理对象类型响应:', res);
      
      if (res.leixing === 'ok') {
        return res;
      } else if (res.leixing === 'error') {
        ElMessage({
          message: res.msg || '序列号校验失败',
          type: 'error',
          duration: 3000
        });
        return res;
      }
    }
    
    // 返回响应数据，不再进一步处理
    return res;
  },
  error => {
    console.log('序列号校验响应错误:', error);
    
    // 检查错误响应中是否包含有效数据
    if (error.response && error.response.data) {
      const responseData = error.response.data;
      
      // 检查是否是JSON字符串
      if (typeof responseData === 'string') {
        try {
          const parsedData = JSON.parse(responseData);
        //   console.log('序列号校验错误响应中解析到的数据:', parsedData);
          
          // 检查是否是 {"leixing":"ok"} 格式
          if (parsedData.leixing === 'ok') {
            // console.log('序列号校验从错误响应中恢复有效数据');
            return Promise.resolve(parsedData);
          } else if (parsedData.leixing === 'error') {
            ElMessage({
              message: parsedData.msg || '序列号校验失败',
              type: 'error',
              duration: 3000
            });
            return Promise.resolve(parsedData);
          }
        } catch (e) {
        //   console.log('序列号校验错误响应不是JSON格式');
        }
      } else if (typeof responseData === 'object' && responseData.leixing === 'ok') {
        // 如果已经是对象且符合格式
        // console.log('序列号校验从错误响应对象中恢复有效数据');
        return Promise.resolve(responseData);
      }
    }
    
    ElMessage.error('序列号校验请求失败，请稍后重试');
    return Promise.reject(error);
  }
);

// 是否正在刷新token
let isRefreshing = false
// 重试队列
let retryRequests = []

// 请求拦截器
service.interceptors.request.use(config => {
  const token = localStorage.getItem('token')
  
  // 添加时间戳防止缓存
  if (config.method === 'get') {
    config.params = {
      ...config.params,
      _t: new Date().getTime()
    }
  }
  
  // 设置token
  if (token) {
    config.headers.Authorization = `Bearer ${token}`
  }
  
  // 请求日志
//   console.log(`请求接口: ${config.url}`, config)
  
  return config
}, error => {
  console.log('请求错误:', error)
  return Promise.reject(error)
})

// 响应拦截器
service.interceptors.response.use(
  response => {
    // console.log('原始响应:', response);
    
    // 直接检查是否有data字段，并且是否有预期的格式
    if (response.data && typeof response.data === 'object' && response.data.leixing === 'ok') {
    //   console.log('直接返回OK响应:', response.data);
      return response.data;
    }
    
    // 检查响应是否为纯文本
    let res;
    
    // 先尝试按照字符串处理
    if (typeof response.data === 'string') {
      try {
        res = JSON.parse(response.data);
        // console.log('解析后的字符串响应:', res);
        
        // 如果是 {"leixing":"ok"} 格式，直接返回
        if (res && res.leixing === 'ok') {
          return res;
        }
      } catch (e) {
        // console.log('响应不是JSON格式，按原样返回:', response.data);
        return response.data; // 如果无法解析，直接返回原始数据
      }
    } else {
      res = response.data;
    }
    
    // 处理对象类型响应
    if (res && typeof res === 'object') {
    //   console.log('处理对象类型响应:', res);
      
      if (res.leixing === 'ok') {
        return res;
      } else if (res.leixing === 'error') {
        // 业务错误
        ElMessage({
          message: res.msg || '请求失败',
          type: 'error',
          duration: 3000
        });
        return res;
      } else if (res.code === 401 || res.leixing === 'nologin') {
        // token失效，需要重新登录
        handleAuthError();
        return Promise.reject(new Error('未登录或登录过期'));
      }
    }
    
    // 返回响应数据，不再进一步处理
    return res;
  },
  error => {
    console.log('响应错误:', error);
    
    // 检查错误响应中是否包含有效数据
    if (error.response && error.response.data) {
      const responseData = error.response.data;
      
      // 检查是否是JSON字符串
      if (typeof responseData === 'string') {
        try {
          const parsedData = JSON.parse(responseData);
        //   console.log('错误响应中解析到的数据:', parsedData);
          
          // 检查是否是 {"leixing":"ok"} 格式
          if (parsedData.leixing === 'ok') {
            // console.log('从错误响应中恢复有效数据');
            return Promise.resolve(parsedData);
          } else if (parsedData.leixing === 'error') {
            ElMessage({
              message: parsedData.msg || '请求失败',
              type: 'error',
              duration: 3000
            });
            return Promise.resolve(parsedData);
          }
        } catch (e) {
        //   console.log('错误响应不是JSON格式');
        }
      } else if (typeof responseData === 'object' && responseData.leixing === 'ok') {
        // 如果已经是对象且符合格式
        // console.log('从错误响应对象中恢复有效数据');
        return Promise.resolve(responseData);
      }
    }
    
    if (error.response) {
      const { status } = error.response;
      
      // 处理不同状态码
      switch (status) {
        case 400:
          ElMessage.error('请求参数错误');
          break;
        case 401:
          handleAuthError();
          break;
        case 403:
          ElMessage.error('没有权限访问该资源');
          break;
        case 404:
          ElMessage.error('请求的资源不存在');
          break;
        case 500:
          ElMessage.error('服务器内部错误');
          break;
        default:
          ElMessage.error('网络异常，请稍后重试');
      }
    } else if (error.message && error.message.includes('timeout')) {
      ElMessage.error('请求超时，请检查网络');
    } else {
      ElMessage.error('网络异常，请稍后重试');
    }
    
    return Promise.reject(error);
  }
)

// 处理认证错误
function handleAuthError() {
  // 避免多次跳转登录页
  if (!isRefreshing) {
    isRefreshing = true
    
    ElMessage({
      message: '登录状态已过期，请重新登录',
      type: 'error',
      duration: 3000,
      onClose: () => {
        localStorage.removeItem('token')
        router.push('/login')
        isRefreshing = false
      }
    })
  }
}

// 刷新token (如果需要)
function refreshToken() {
  // 这里可以实现刷新token的逻辑
}

// 用于确定API路径的辅助函数
export const getApiPath = (ctype) => {
  // 序列号校验用的是xcxpost
  if (ctype === 'zlxt_3_shujuk_bdym') {
    return '/xcx/ajax/Ajax_xcxpost.ashx'
  }
  // 其他接口用的是apppost
  return '/xcx/ajax/Ajax_apppost.ashx'
}

// Base64 编码工具
const encodeBase64 = (obj) => {
  if (typeof obj === 'string') {
    return btoa(obj)
  }
  return btoa(JSON.stringify(obj))
}

// Base64 解码工具
const decodeBase64 = (str) => {
  try {
    const decoded = atob(str)
    return JSON.parse(decoded)
  } catch (error) {
    return decoded
  }
}

// 封装统一的请求方法
export const apiRequest = {
  /**
   * 通用业务接口请求
   * @param {Object} params - 请求参数
   * @param {string} params.ctype - 接口类型
   * @param {Object} params.bs64_cs - base64编码的查询参数
   * @param {Object} params.bs64_obj - base64编码的对象参数
   * @param {Object} params.bs64_list - base64编码的列表参数
   * @param {string} params.faid - 功能ID
   * @param {string} params.ids - ID列表
   * @returns {Promise} 请求结果
   */
  async post(params) {
    // console.group('📤 API请求')
    // console.log('🎯 接口类型:', params.ctype)
    // console.log('📋 请求参数:', params)
    
    try {
      const apiPath = getApiPath(params.ctype)
      console.log('🔗 请求路径:', apiPath)
      
      const response = await service.post(apiPath, { canshu: params })
      
      console.log('✅ 请求成功')
      console.log('📥 响应数据:', response)
      console.groupEnd()
      
      return response
    } catch (error) {
      console.log('❌ 请求失败:', error)
      console.groupEnd()
      throw error
    }
  },

  /**
   * 序列号验证请求
   * @param {Object} params - 验证参数
   * @param {string} params.ctype - 固定为 'zlxt_3_shujuk_bdym'
   * @param {Object} params.bs64_cs - base64编码的验证参数
   * @returns {Promise} 验证结果
   */
  async verifySerial(params) {
    console.group('🔒 序列号验证')
    console.log('📋 验证参数:', params)
    
    try {
      const response = await serialVerifyService.post('/xcx/ajax/Ajax_xcxpost.ashx', { canshu: params })
      
      console.log('✅ 验证成功')
      console.log('📥 验证结果:', response)
      console.groupEnd()
      
      return response
    } catch (error) {
      console.log('❌ 验证失败:', error)
      console.groupEnd()
      throw error
    }
  },

  /**
   * 菜单数据请求
   * @param {string} openid - 用户openid
   * @param {string} version - 版本号，默认 '5.2.06121'
   * @returns {Promise} 菜单数据
   */
  async getMenuData(openid, version = '5.2.06121') {
    const bs64_cs = {
      openid,
      banbenhao: version
    }
    
    const params = {
      ctype: 'zlxt_3_get_index',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 业务数据列表请求
   * @param {Object} queryParams - 查询参数
   * @param {number} queryParams.cxlx - 查询类型
   * @param {number} queryParams.faid - 功能ID
   * @param {number} queryParams.pagenumber - 页码，默认1
   * @param {string} queryParams.key - 搜索关键字
   * @param {string} queryParams.yewuy - 业务员
   * @param {string} queryParams.openid - 用户openid
   * @param {string} queryParams.liuchengbh - 流程编号
   * @returns {Promise} 业务数据
   */
  async getBusinessList(queryParams) {
    const {
      cxlx = 0,
      faid = 0,
      pagenumber = 1,
      key = '',
      yewuy = '',
      openid = '',
      liuchengbh = '',
      ...otherParams
    } = queryParams
    
    const bs64_cs = {
      dtype: '',
      pagenumber,
      id: 0,
      key,
      yewuy,
      openid,
      cxlx,
      kehusbbh: '',
      cx_kehulx: '',
      cx_yewuy: '',
      liuchengbh,
      ...otherParams
    }
    
    const params = {
      ctype: '',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      faid,
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 选择参数请求
   * @param {Object} selectParams - 选择参数
   * @param {string} selectParams.wtype - 参数类型
   * @param {string} selectParams.key - 搜索关键字
   * @param {string} selectParams.openid - 用户openid
   * @param {number} selectParams.faid - 功能ID
   * @returns {Promise} 参数选项
   */
  async getSelectParams(selectParams) {
    const { wtype, key = '', openid, faid = 0 } = selectParams
    
    const bs64_cs = {
      wtype,
      key,
      openid
    }
    
    const params = {
      ctype: 'app_xuanze_canshu',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      ids: '',
      faid
    }
    
    return this.post(params)
  },

  /**
   * 用户登录请求
   * @param {Object} loginData - 登录数据
   * @param {string} loginData.username - 用户名
   * @param {string} loginData.password - 密码
   * @param {string} loginData.openid - openid
   * @returns {Promise} 登录结果
   */
  async login(loginData) {
    const { username, password, openid } = loginData
    
    const bs64_cs = {
      yonghuming: username,
      mima: password,
      openid,
      banbenhao: '5.2.06121'
    }
    
    const params = {
      ctype: 'zlxt_3_denglu',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 通用数据保存请求
   * @param {Object} saveData - 保存数据
   * @param {string} saveData.ctype - 操作类型
   * @param {Object} saveData.dataObj - 要保存的数据对象
   * @param {number} saveData.faid - 功能ID
   * @param {string} saveData.openid - 用户openid
   * @returns {Promise} 保存结果
   */
  async saveData(saveData) {
    const { ctype, dataObj, faid = 0, openid } = saveData
    
    const bs64_cs = {
      openid,
      ...dataObj
    }
    
    const params = {
      ctype,
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      faid,
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 获取客户详情编辑表单配置
   * @param {Object} formParams - 表单参数
   * @param {string} formParams.openid - 用户openid
   * @param {number} formParams.cxlx - 查询类型，默认201
   * @param {number} formParams.faid - 功能ID
   * @param {string} formParams.liuchengbh - 流程编号
   * @param {string} formParams.qiyebh - 企业编号（可选）
   * @param {string} formParams.key - 搜索关键字（可选）
   * @returns {Promise} 表单配置数据
   */
  async getCustomerFormConfig(formParams) {
    const {
      openid,
      cxlx = 201,
      faid,
      liuchengbh = 'undefined',
      qiyebh = '',
      key = ''
    } = formParams
    
    const bs64_cs = {
      qiyebh,
      key,
      cxlx,
      img_is_zj: 0,
      openid,
      liuchengbh
    }
    
    const params = {
      ctype: 'app_zlxt_xq_edit',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      ids: '',
      faid
    }
    
    return this.post(params)
  },

  /**
   * 营业执照识别
   * @param {Object} licenseParams - 营业执照识别参数
   * @param {string} licenseParams.openid - 用户openid
   * @param {string} licenseParams.imgBase64 - 营业执照图片Base64
   * @param {number} licenseParams.faid - 功能ID
   * @returns {Promise} 识别结果
   */
  async recognizeBusinessLicense(licenseParams) {
    const { openid, imgBase64, faid = 0 } = licenseParams
    
    const bs64_cs = {
      openid,
      img_base64: imgBase64
    }
    
    const params = {
      ctype: 'app_kehusyingyezz',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      ids: '',
      faid
    }
    
    return this.post(params)
  },

  /**
   * 身份证识别
   * @param {Object} idCardParams - 身份证识别参数
   * @param {string} idCardParams.openid - 用户openid
   * @param {string} idCardParams.imgBase64 - 身份证图片Base64
   * @param {string} idCardParams.side - 身份证面 'front'(正面) 或 'back'(反面)
   * @param {number} idCardParams.faid - 功能ID
   * @returns {Promise} 识别结果
   */
  async recognizeIdCard(idCardParams) {
    const { openid, imgBase64, side = 'front', faid = 0 } = idCardParams
    
    const bs64_cs = {
      openid,
      img_base64: imgBase64
    }
    
    // 根据正反面选择不同的接口类型
    const ctype = side === 'front' ? 'app_kehushenfenz' : 'app_kehushenfezfm'
    
    const params = {
      ctype,
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      ids: '',
      faid
    }
    
    return this.post(params)
  },

  /**
   * 保存客户信息
   * @param {Object} customerData - 客户数据
   * @param {string} customerData.openid - 用户openid
   * @param {number} customerData.faid - 功能ID
   * @param {Object} customerData.formData - 表单数据
   * @param {string} customerData.qiyebh - 企业编号
   * @returns {Promise} 保存结果
   */
  async saveCustomerInfo(customerData) {
    const { openid, faid, formData, qiyebh } = customerData
    
    const bs64_cs = {
      openid,
      qiyebh,
      ...formData
    }
    
    const params = {
      ctype: 'app_zlxt_xq_save',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      faid,
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 获取业务员列表
   * @param {Object} salesParams - 业务员查询参数
   * @param {string} salesParams.openid - 用户openid
   * @param {string} salesParams.key - 搜索关键字
   * @param {number} salesParams.faid - 功能ID
   * @returns {Promise} 业务员列表
   */
  async getSalesList(salesParams) {
    const { openid, key = '', faid = 0 } = salesParams
    
    const bs64_cs = {
      wtype: 'app_yewuy',
      key,
      openid
    }
    
    const params = {
      ctype: 'app_xuanze_canshu',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      ids: '',
      faid
    }
    
    return this.post(params)
  },

  /**
   * 获取客户分类列表
   * @param {Object} categoryParams - 客户分类查询参数
   * @param {string} categoryParams.openid - 用户openid
   * @param {string} categoryParams.key - 搜索关键字
   * @param {number} categoryParams.faid - 功能ID
   * @returns {Promise} 客户分类列表
   */
  async getCustomerCategoryList(categoryParams) {
    const { openid, key = '', faid = 0 } = categoryParams
    
    const bs64_cs = {
      wtype: 'app_chengzuflx',
      key,
      openid
    }
    
    const params = {
      ctype: 'app_xuanze_canshu',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      ids: '',
      faid
    }
    
    return this.post(params)
  },

  /**
   * 获取动态表单配置和数据（通用编辑页面）
   * @param {Object} editParams - 编辑页面参数
   * @param {string} editParams.openid - 用户openid
   * @param {number} editParams.cxlx - 查询类型
   * @param {number} editParams.faid - 功能ID
   * @param {number} editParams.id - 记录ID（编辑时传入，新增时为0）
   * @param {string} editParams.ctype - 操作类型，默认'edit'
   * @returns {Promise} 表单配置和数据
   */
  async getDynamicFormConfig(editParams) {
    const {
      openid,
      cxlx,
      faid,
      id = 0,
      ctype = 'edit'
    } = editParams
    
    const bs64_cs = {
      dtype: ctype,
      id,
      openid,
      cxlx,
      key: '',
      yewuy: ''
    }
    
    const params = {
      ctype: 'app_zlxt_xq_edit',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      faid,
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 保存动态表单数据
   * @param {Object} saveParams - 保存参数
   * @param {string} saveParams.openid - 用户openid
   * @param {number} saveParams.faid - 功能ID
   * @param {number} saveParams.id - 记录ID
   * @param {string} saveParams.ctype - 保存类型
   * @param {Object} saveParams.formData - 表单数据
   * @param {Array} saveParams.shuzu_sb - 设备数组数据
   * @param {string} saveParams.dtype - 数据类型
   * @returns {Promise} 保存结果
   */
  async saveDynamicForm(saveParams) {
    const {
      openid,
      faid,
      id = 0,
      ctype,
      formData,
      shuzu_sb = [],
      dtype = 'edit'
    } = saveParams
    
    const bs64_cs = {
      dtype,
      id,
      openid,
      yewuy: '',
      key: ''
    }
    
    const params = {
      ctype,
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: encodeBase64(formData),
      bs64_list: encodeBase64(shuzu_sb),
      faid,
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 获取动态选择参数数据
   * @param {Object} selectParams - 选择参数
   * @param {string} selectParams.wtype - 参数类型
   * @param {string} selectParams.openid - 用户openid
   * @param {number} selectParams.faid - 功能ID
   * @param {string} selectParams.key - 搜索关键字
   * @param {number} selectParams.pagenumber - 页码
   * @param {number} selectParams.cxlx - 查询类型
   * @returns {Promise} 选择参数数据
   */
  async getDynamicSelectData(selectParams) {
    const {
      wtype,
      openid,
      faid,
      key = '',
      pagenumber = 0,
      cxlx = 0
    } = selectParams
    
    const bs64_cs = {
      wtype,
      pagenumber,
      cxlx,
      key,
      openid
    }
    
    const params = {
      ctype: 'app_xuanze_canshu',
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      faid,
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 提交流程
   * @param {Object} submitParams - 提交参数
   * @param {string} submitParams.openid - 用户openid
   * @param {number} submitParams.faid - 功能ID
   * @param {number} submitParams.id - 记录ID
   * @param {string} submitParams.ctype - 提交类型
   * @returns {Promise} 提交结果
   */
  async submitWorkflow(submitParams) {
    const {
      openid,
      faid,
      id,
      ctype = 'app_zlxt_liucheng_tijiao'
    } = submitParams
    
    const bs64_cs = {
      openid,
      id
    }
    
    const params = {
      ctype,
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      faid,
      ids: ''
    }
    
    return this.post(params)
  },

  /**
   * 删除记录
   * @param {Object} deleteParams - 删除参数
   * @param {string} deleteParams.openid - 用户openid
   * @param {number} deleteParams.faid - 功能ID
   * @param {number} deleteParams.id - 记录ID
   * @param {string} deleteParams.ctype - 删除类型
   * @returns {Promise} 删除结果
   */
  async deleteRecord(deleteParams) {
    const {
      openid,
      faid,
      id,
      ctype = 'app_zlxt_del'
    } = deleteParams
    
    const bs64_cs = {
      openid,
      id
    }
    
    const params = {
      ctype,
      bs64_cs: encodeBase64(bs64_cs),
      bs64_obj: '',
      bs64_list: '',
      faid,
      ids: ''
    }
    
    return this.post(params)
  }
}

// 便捷方法别名
export const api = apiRequest

// 兼容旧的调用方式
export const request = service

// 兼容性函数：简化的 postRequest
export const postRequest = async (url, data) => {
  try {
    let requestUrl = url
    let requestData = data
    
    // 如果是空字符串或没传URL，且data包含ctype，表示是原始格式的请求
    if (!url || url === '') {
      if (data && data.ctype) {
        // 使用原始API路径格式
        requestUrl = '/xcx/ajax/Ajax_apppost.ashx'
        requestData = { canshu: data }
        
        // console.log('测试打印数据 使用原始API格式')
        // console.log('测试打印数据 请求URL:', requestUrl)
        // console.log('测试打印数据 请求数据:', requestData)
      }
    }
    
    const response = await service.post(requestUrl, requestData)
    return response
  } catch (error) {
    console.log('POST请求失败:', error)
    throw error
  }
}

// 兼容性函数：简化的 getRequest  
export const getRequest = async (url, params) => {
  try {
    const response = await service.get(url, { params })
    return response
  } catch (error) {
    console.log('GET请求失败:', error)
    throw error
  }
}

// 兼容旧版本的 request 对象格式
const http = {
  /**
   * 兼容旧版本的 request 方法
   * @param {Object} config - 请求配置
   * @param {string} config.method - 请求方法
   * @param {Object} config.data - 请求数据
   * @returns {Promise} 请求结果
   */
  async request(config) {
    try {
      // console.log('测试打印数据 使用兼容版本的 http.request')
      // console.log('测试打印数据 请求配置:', config)
      
      const { method = 'POST', data } = config
      let response
      
      if (method.toUpperCase() === 'POST') {
        // 检查是否是标准的 { canshu: {...} } 格式
        if (data && data.canshu) {
          response = await service.post('/xcx/ajax/Ajax_apppost.ashx', data)
        } else {
          response = await service.post('/xcx/ajax/Ajax_apppost.ashx', { canshu: data })
        }
      } else {
        response = await service.get('/xcx/ajax/Ajax_apppost.ashx', { params: data })
      }
      
      // console.log('测试打印数据 兼容请求响应:', response)
      return response
    } catch (error) {
      console.log('兼容请求失败:', error)
      throw error
    }
  }
}

// 默认导出 service 实例，保持向后兼容（登录页面等需要）
export default service

// 导出 http 对象供需要 .request() 方法的页面使用
export { http }

// 导出工具函数
export { encodeBase64, decodeBase64 }
